package com.flappySeeker.util;

import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;
import java.util.UUID;
import java.text.ParseException;
import java.text.DecimalFormat;
import java.util.regex.*;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.apache.commons.lang3.time.DateUtils;

import com.flappySeeker.controller.MBTI;

public class GetTools {

	/**
	 * 生成GUID 全球唯一的ID At:杨正辉
	 * @return 返回生成的GUID：string
	 */
	public static final String GetGUID() {
		UUID uuid = UUID.randomUUID();
		String ruid = "";
		if (uuid.toString().length() <= 32) {
			ruid = uuid.toString();
		} else {
			ruid = uuid.toString().replace("-", "");
		}
		return ruid;
	}

	/**
	 * Date数据类型转换成Timestamp类型At 杨正辉
	 * @param data Date数据类型值
	 * @return 返回Timestamp类型值
	 */
	public static final Timestamp date2TimesTamp(Date data) {
		return new Timestamp(data.getTime());
	}
	
	/**将date对象拼装成一个字符串  辜栋利
	 * @param date date对象；format  null默认格式方式yyyy-MM-dd HH:mm:ss
	 * @return 时间字符串
	 */
	public static String dateTstr(Date date,String format){
		return DateFormatUtils.format(date, format==null?"yyyy-MM-dd HH:mm:ss":format);
	}
	/**将字符串转date 
	 * @param 时间字符串；format null默认格式方式yyyy-MM-dd HH:mm:ss
	 * @return date 
	 * @throws ParseException 
	 */
	public static Date strTdate(String date,String format) {
		try {
			return DateUtils.parseDate(date, format==null?"yyyy-MM-dd HH:mm:ss":format);
		} catch (ParseException e) {
			e.printStackTrace();return null;
		}
	}
	/**
	 * @return 当前日期格式 "yyyy-MM-dd HH:mm:ss"
	 */
	 public static String getNowDateTime(){
		 return dateTstr(new Date(), null);
	 }
	 
	 public static Timestamp String2Timestamp(String datetime){
		 try {
			return  new Timestamp(strTdate(datetime, null).getTime());
		} catch (Exception e) {
			e.printStackTrace(); return null;
		}
	 }
	 
	 /**
	  * 计算两个日期的时间差,返回相差的秒数AT 杨正辉
	  * @param formatTime1
	  * @param formatTime2
	  * @return
	  */
	 public static int getTimeDifference2sec(Timestamp formatTime1, Timestamp formatTime2) {
		 return (int)(formatTime1.getTime()-formatTime2.getTime())/1000;
		 }
	 /**
	  * 计算两个日期的时间差,返回相差的小时数 AT 杨正辉
	  * @param formatTime1
	  * @param formatTime2
	  */
	 public static int getTimeDifference(Timestamp formatTime1, Timestamp formatTime2) {
		 return getTimeDifference2sec(formatTime1,formatTime2)/3600;
	 }
	 
	 /**按longNum随机生成数字长库
	 * @param longNum长度，如1.
	 * @return字符串
	 */
	public static String getStrBitRan(int longNum) {
		return ""+randomInt(longNum);
	 }
	 
    /**
     * 对新增实体保存时需要增加当前时间
     * 后期可以扩展
     * @param request
     * @return
     */
    public static void setBeanProperty(Object bean) {
    	try {
    		Class<?> cls =bean.getClass();
    		Field field = cls.getDeclaredField("createtime");
    		field.setAccessible(true);
    		field.set(bean, new Timestamp(System.currentTimeMillis()));
		}  catch (Exception e) {
			e.printStackTrace();
		}
    }

	public static int randomId() { 
		return  Math.abs((int) System.currentTimeMillis());
    }
    
    /**
     * 对前台传参数解析 格式 coursename=a&&b=b&&c=c;
     * @param String  @return Map<String, Object>
     */
	public static Map<String, Object> analyParam(String param) {
		Map<String, Object> map = new HashMap<String, Object>();
		String[] a = param.split("&&");
		for (String str : a) {
			String[] b = str.split("=");
			try{
			map.put(b[0], b[1]);
			}catch (Exception e) {
				map.put(b[0], "");
			}
		}
		return map;
	}
    /**
     * 将同类型对象A复制到B中
     * @author Administrator 辜栋利
     * @param Object source, Object target
     */
	public static void copyProperties(Object source, Object target) {
		try {
			BeanUtils.copyProperties(target, source);
		} catch ( Exception e) {
			e.printStackTrace();
		}
	}
	 /**
     * 将同类型对象A中不为空的属性，复制到B中
     * @param Object source, Object target
     */
	public static void beanToBean(Object source, Object target) {
		try{
			if(!source.getClass().getName().equals(target.getClass().getName())){
				throw new Exception("不同类型的数据不能进行复制");
			}
			Field[] fields = source.getClass().getDeclaredFields();
			Class<?> targetcls =target.getClass();
			for (Field field : fields) {
				if(Modifier.isStatic(field.getModifiers()))continue ;
				field.setAccessible(true);
				Object value = field.get(source);
				if(value!=null){
					Field f = targetcls.getDeclaredField(field.getName());
					f.setAccessible(true);
					f.set(target, value);
				}
			}
		}catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	 /**
     * 将对象中为空的设置默认为‘’或者0，设置当前时间
     * @param Object source
     */
	public static void setdefault(Object source) {
		try {
			Class<?>  cls = source.getClass();
			Field[] fields = cls.getDeclaredFields();
			for (Field field : fields) {
				if(Modifier.isStatic(field.getModifiers()))continue ;
				field.setAccessible(true);
				Object value = field.get(source);
				if(value!=null)continue ;
				String simplename =field.getType().getSimpleName();
				if(simplename.equals("String")){
					field.set(source, "");
				}else if(simplename.equals("Timestamp")){
					field.set(source, new Timestamp(System.currentTimeMillis()));
				}else if(simplename.equals("Date")){
					field.set(source, new Date(System.currentTimeMillis()));
				}else if(simplename.equals("Double")){
					field.set(source, 0.0);
				}else if(simplename.equals("Integer")){
					field.set(source, 0);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	 /**
     *	将文件更名 路径必须是绝对路径
     * @author Administrator 辜栋利
     * @param String f1  f2
     */
	public  static void file2newFile(String f1 ,String f2){
		new File(f1).renameTo(new File(f2));
	}
	
	/**
	 * 将字符串转为 ISO88591 标准
	 * @author 姜磊
	 * @param str
	 * @return
	 */
	public static String toISO88591(String str) {
		try {
			str = new String(str.getBytes("UTF-8"), "ISO-8859-1");
		} catch (UnsupportedEncodingException ex) {
			ex.printStackTrace();
		}
		return str;
	}

	/**
	 * 截取字符串
	 * @param str 字符串
	 * @param width 截取长度
	 * @param end 结尾替代符
	 */
	public static String doSubstr(String str, int width, String end) { 
		str =StringUtils.substring(str, 0,width);
		return str.length()>(width-end.length())?(StringUtils.substring(str, 0,width-end.length())+end):str;
	}
	/**
	 * 过滤HTML标签
	 * @author 姜磊
	 * @param inputString HTML字符串
	 * @return
	 */
	public static String Html2Text(String inputString) {
        String htmlStr = inputString; // 含html标签的字符串  
        String textStr = "";  
        Pattern p_script;  
        Matcher m_script;  
        Pattern p_style;  
        Matcher m_style;  
        Pattern p_html;  
        Matcher m_html;  
        Pattern p_html1;  
        Matcher m_html1;  
        try {  
            String regEx_script = "<[\\s]*?script[^>]*?>[\\s\\S]*?<[\\s]*?\\/[\\s]*?script[\\s]*?>";
            String regEx_style = "<[\\s]*?style[^>]*?>[\\s\\S]*?<[\\s]*?\\/[\\s]*?style[\\s]*?>";
            String regEx_html = "<[^>]+>";
            String regEx_html1 = "<[^>]+";  
            p_script = Pattern.compile(regEx_script, Pattern.CASE_INSENSITIVE);  
            m_script = p_script.matcher(htmlStr);  
            htmlStr = m_script.replaceAll("");
  
            p_style = Pattern.compile(regEx_style, Pattern.CASE_INSENSITIVE);  
            m_style = p_style.matcher(htmlStr);  
            htmlStr = m_style.replaceAll("");
  
            p_html = Pattern.compile(regEx_html, Pattern.CASE_INSENSITIVE);  
            m_html = p_html.matcher(htmlStr);  
            htmlStr = m_html.replaceAll("");
  
            p_html1 = Pattern.compile(regEx_html1, Pattern.CASE_INSENSITIVE);  
            m_html1 = p_html1.matcher(htmlStr);  
            htmlStr = m_html1.replaceAll("");
            textStr = htmlStr;  
        } catch (Exception e) {  
            System.err.println("Html2Text: " + e.getMessage());  
        }  
        return textStr;
    }
	
	
	/**
	 * 在指定目录下创建文件夹
	 * @param path 文件夹创建路径
	 * @param name 文件夹名称
	 */
	public static boolean MakeDir(String path, String name){
		try {
			if(!new File(path).isDirectory()) return false;
			FileUtils.forceMkdir(new File(path+"/"+name));return true;
		} catch (IOException e) {
			e.printStackTrace();
			return false;
		}
	}
	/**
	 * 将文件大小转换为KB或MB
	 * @param size @return String
	 */
	public static String getFileSizeString(long size){
		DecimalFormat df = new DecimalFormat("###.##");
		if (size < 1024){
			return size+"B";
		}else if ( size < 1048576) {
		    return df.format((float)size/1024)+"KB";
		}else if ( size < 1073741824){
		    return df.format((float)size/1048576)+"MB";
		}else{
		    return df.format((float)size/1073741824)+"G";
		}
	}
	/**2012-11-07T00:00:00的后一天
	 * @param date
	 * @return
	 */
	public static String strnextlong(String date){
   		Timestamp ts = Timestamp.valueOf(date.toString().replace("T", " "));
   		return dateTstr(DateUtils.addDays(new Date(ts.getTime()), 1), null);
	}
	/**zhangtao
	 * 生成纯数字id号
	 * @return string
	 */
	public static String makenums(){
		return dateTstr(new Date(), "yyyyMMddHHmmssSSS")+"00"+Math.round(Math.random()*899+100);
	}
	/** 
	 * 生成随机几位数
	 * @param n @return int
	 */
	public static int randomInt(int n) {
		double a = Math.random();
		return (int) (Math.pow(10, n-Math.ceil(Math.log10(a)))*a);
	}
	/**
	 * MD5加密
	 */
	public static String getMD5(String str) {
		return DigestUtils.md5Hex(str);
    }
	
	 /**  
	  *  判断某个字符串是否存在于数组中
	  *  @param stringArray 原数组
	  *  @param source 查找的字符串
	  *  @return 是否找到
	  */
	public static boolean getContains(String[] stringArray, String source) {
		return ArrayUtils.contains(stringArray, source);
	} 
	  /**  
     * 对double数据进行取精度.  
     * @param value  double数据.  
     * @param scale  精度位数(保留的小数位数).  
     * @param roundingMode  精度取值方式.  
     * @return 精度计算后的数据.  
     */  
    public static double round(double value, int scale, int roundingMode) {   
        return new BigDecimal(Double.toString(value)).setScale(scale, roundingMode).doubleValue(); 
    }   
	  /**  
     * 对double数据进行取精度.  
     * @param value  double数据.  
     * @param scale  精度位数(保留的小数位数).  默认四舍五入
     * @return 精度计算后的数据.  
     */  
    public static double round(double value, int scale) {   
    	return new BigDecimal(Double.toString(value)).setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue(); 
    }
    /** 
     * double 相加 保证精度
     * @param scale 精度 
     * @param values 多个参数 
     */ 
    public static double numAdd(int scale,double... values){ 
    	BigDecimal sum = new BigDecimal("0");
    	for (double d : values) {
    		sum=sum.add(new BigDecimal(Double.toString(d)));
		}
    	return sum.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue(); 
    } 
    /** 
     * double 相减 保证精度
     * @param scale 精度 
     * @param values 多个参数  mvalue 被减数
     */ 
    public static double numSub(int scale,double mvalue,double... values){ 
    	BigDecimal sum = new BigDecimal(Double.toString(mvalue));
    	for (double d : values) {
    		sum=sum.subtract(new BigDecimal(Double.toString(d)));
		}
    	return sum.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue(); 
    } 
    
    /** 
     * double 相乘 保证精度
     * @param scale 精度 
     * @param values 多个参数  
     */ 
    public static double numMul(int scale,double... values){ 
    	BigDecimal sum = new BigDecimal("1");
    	for (double d : values) {
    		sum=sum.multiply(new BigDecimal(Double.toString(d)));
		}
    	return sum.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue(); 
    } 
    
    /** 
     * double 相除 保证精度
     * @param scale 精度 
     * @param values 多个参数  mvalue 被除数
     */ 
    public static double numDiv(int scale,double mvalue,double... values){ 
    	BigDecimal sum = new BigDecimal(Double.toString(mvalue));
    	for (double d : values) {
    		sum=sum.divide(new BigDecimal(Double.toString(d)),scale+1,BigDecimal.ROUND_HALF_UP);
		}
    	return sum.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue(); 
    } 
    
     /** 
     * double 相加 
     * @param d1 
     * @param d2 
     */ 
    public static double sum(double d1,double d2){ 
        BigDecimal bd1 = new BigDecimal(Double.toString(d1)); 
        BigDecimal bd2 = new BigDecimal(Double.toString(d2)); 
        return bd1.add(bd2).doubleValue(); 
    } 

    /** 
     * double 相减 
     * @param d1 
     * @param d2 
     */ 
    public static double sub(double d1,double d2){ 
        BigDecimal bd1 = new BigDecimal(Double.toString(d1)); 
        BigDecimal bd2 = new BigDecimal(Double.toString(d2)); 
        return bd1.subtract(bd2).doubleValue(); 
    } 

    /** 
     * double 乘法 
     * @param d1 
     * @param d2 
     */ 
    public static double mul(double d1,double d2){ 
        BigDecimal bd1 = new BigDecimal(Double.toString(d1)); 
        BigDecimal bd2 = new BigDecimal(Double.toString(d2)); 
        return bd1.multiply(bd2).doubleValue(); 
    } 


    /** 
     * double 除法 
     * @param d1 
     * @param d2 
     * @param scale 四舍五入 小数点位数 
     */ 
    public static double div(double d1,double d2,int scale){ 
        //  当然在此之前，你要判断分母是否为0， 为0你可以根据实际需求做相应的处理 
        BigDecimal bd1 = new BigDecimal(Double.toString(d1)); 
        BigDecimal bd2 = new BigDecimal(Double.toString(d2)); 
        return bd1.divide(bd2,scale,BigDecimal.ROUND_HALF_UP).doubleValue(); 
    } 
	
    /**
     * 匹配字符串
     * @param matcher 被匹配字符串
     * @param pattern	匹配规则
     */
    public static boolean matcherPattern(String matcher,String pattern){ 
         return Pattern.compile(pattern).matcher(matcher).matches();
    } 
    /**
     * SQL使用LIKE查询时特殊字符处理
     * @param str  @return str
     */
    public static String correctLikeQuerywords (String str) {
    	String new_str = str.replace("'", "''").replace("/","//").replace("%", "/%").replace("_", "/_");
    	return new_str;	    
    }
    
    public final static String FORMAT_NUM ="%.2f";
    /**
     * 数字保留两位小数字符串
     * @param Object  @return str
     */
    public static String numTstr (Object num) {
    	return String.format(FORMAT_NUM, num);	    
    }
    /**
     * 字符串数组排序
     * @param S,E,C,R,I,A  @return str
     */
    public static String arystrsort (String str) {
    	String[] ary =str.split(",");
    	Arrays.sort(ary);
    	StringBuilder sb = new StringBuilder();
    	for (String s : ary) {
    		sb.append(",").append(s);
		}
    	return sb.substring(1);
    }
    /**
     * MAP 根据key排序
     */
    public static void sortByKey( Map<String, Integer> map) {  
        TreeMap<String, Integer> treeMap = new TreeMap<String, Integer>(map);  
        for (String key : treeMap.keySet()) {  
            System.out.printf("key:%s, value:%d\n", key, map.get(key));  
        }  
    } 
    /**
     * MAP 根据value排序
     */
    public static ArrayList<Entry<String, Integer>> sortByValue(Map<String, Integer> map) {  
        ArrayList<Entry<String, Integer>> entries = new ArrayList<Entry<String, Integer>>(map.entrySet());  
        Collections.sort(entries, new Comparator<Map.Entry<String, Integer>>() {  
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {  
                return (o2.getValue() - o1.getValue()); // 降序  
            }  
        });  
        /*System.out.println( entries.get(0) );
        for (Entry<String, Integer> entry : entries) {  
            System.out.printf("key:%s, value:%d\n", entry.getKey(), entry.getValue());  
        } */ 
        return entries;
    }  
    /**
     * 获得前多少位，并且根据strs 进行排序
     */
    public static String sortStr(ArrayList<Entry<String, Integer>> list,int top,String[] strs) {
    	StringBuilder temp=new StringBuilder(),
    			res=new StringBuilder();
    	for (int i = 0; i < top; i++) {
    		temp.append(list.get(i).getKey());
		}
    	for (String s : strs) {
    		res.append(temp.indexOf(s)>-1?s:"");
		}
    	return res.toString();
    }
    /**
     * 字符串a,b,c,a,b转Map<String, Integer> 统计次数
     */
    public static Map<String, Integer> strTmap( String str) {
    	String[] ans =str.split(",");
    	int len =ans.length;
    	Map<String, Integer> m= new HashMap<String, Integer>();
		for (int i = 0; i < len; i++) {
			String mt =ans[i];
			int mtv=m.get(mt)==null?0:m.get(mt);
			m.put(mt, mtv+1);
		}
    	return m;
    }
    
    /**
     * 排除map 中有空值问题
     */
    public static int mapval( Map<String, Integer> m, String key) {
    	return m.get(key)==null?0:m.get(key);
    }
}
